Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFcCalendarToast.razor.cs`:
- Around line 8-21: The RemoveAfterDelay method mutates _toasts without
dispatcher protection on line 19, creating a race condition with the Razor
template's foreach loop. Additionally, delayed removal tasks are never canceled
when the component is disposed. To fix this, wrap the _toasts.RemoveAll() call
inside RemoveAfterDelay with InvokeAsync() to ensure it runs on the renderer
dispatcher. Next, create a collection to track CancellationTokenSource objects
for each delayed removal task, modify RemoveAfterDelay to accept a
CancellationToken and check it after the Task.Delay, and implement
IAsyncDisposable on the component class to cancel all pending removal tasks when
the component is disposed.

---

Major comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.razor.cs`:
- Around line 156-159: The ResolveCulture() method in BitFullCalendar.razor.cs
attempts to instantiate CultureInfo with a user-provided name without handling
potential exceptions. Wrap the CultureInfo(name) constructor call in a try-catch
block that catches CultureNotFoundException and falls back to the default
culture (Culture ?? CultureInfo.CurrentUICulture) when an invalid culture name
is provided. This prevents the component initialization from failing due to
invalid CultureName parameter values.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.scss`:
- Line 3: Remove the `.scss` file extension from the import statement in the
BitFullCalendar.scss file. The import path for the functions partial currently
includes `functions.scss` but should be changed to `functions` (without the
extension) to comply with the scss/load-partial-extension linting rule. Update
the import statement to remove the `.scss` extension while keeping the relative
path and quotes intact.
- Line 197: The keyframe names bfcFadeIn and bfcSlideUp are using camelCase
naming, which violates the stylelint keyframes-name-pattern rule that requires
kebab-case. Rename bfcFadeIn to bfc-fade-in and bfcSlideUp to bfc-slide-up in
both their keyframe definitions (where they are declared with `@keyframes`) and in
all animation property references throughout the BitFullCalendar.scss file.
Ensure all 8 occurrences are updated consistently to use the kebab-case format.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.ts`:
- Around line 113-134: In the endResize function, the OnResizeEnd call must
always execute even if the OnResizeMove invocation fails. Wrap the await
dotNetRef.invokeMethodAsync call for OnResizeMove in a try-finally block, and
move the await dotNetRef.invokeMethodAsync call for OnResizeEnd into the finally
block to guarantee it always executes regardless of whether the OnResizeMove
call succeeds or throws an error. Apply the same fix to the corresponding
endResize function in the other section mentioned at lines 183-204.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcAddEditEventDialog.razor`:
- Around line 16-17: Labels in the BitFcAddEditEventDialog component are not
programmatically associated with their corresponding input controls, which
breaks accessibility for screen readers. Add a unique id attribute to each input
element (the text inputs near the TitleLabel, and other form fields at lines
25-26, 30-31, 39-40, 49-50, and 76-79), then add a for attribute to each label
element that matches the id of its paired input. For example, add
id="_titleInput" to the input with `@bind`="_title" and add for="_titleInput" to
the label for TitleLabel.
- Around line 68-70: The attendee remove button at line 68 is an icon-only
button without an accessible label, which makes it unclear to assistive
technologies. Add an aria-label attribute to the button element that calls
RemoveAttendee(attendee) to provide a descriptive accessible name such as
"Remove attendee" or "Remove [attendee name]" so screen readers can properly
announce the button's purpose to users.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcDateTimePicker.razor.cs`:
- Around line 71-74: The OnFocusOut method closes the picker unconditionally
whenever any internal element loses focus, causing the picker to close when
focus moves between internal controls like the trigger button and time/day
controls. Modify the OnFocusOut method to check whether focus is moving to
another element within the component container before closing the picker. You
should verify if the newly focused element (accessible through FocusEventArgs or
related properties) is still a child of the component, and only set _isOpen to
false when focus actually leaves the entire component bounds.
- Around line 54-57: In the SelectDate method, the new DateTime being
constructed uses date.Kind as the DateTimeKind parameter, which can
inadvertently downgrade a previously set Utc or Local kind to Unspecified. To
preserve the bound DateTimeKind, replace date.Kind with Value.Kind when
constructing the selected DateTime object, ensuring the original kind property
is maintained throughout the selection process.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcDateNavigator.razor`:
- Around line 4-11: The icon-only navigation buttons using
State.NavigatePrevious and State.NavigateNext rely only on the title attribute
for accessibility, which may not be consistently announced by assistive
technologies. Add aria-label attributes to both buttons with descriptive text
matching the button's purpose (e.g., "Previous" and "Next"), and also add
type="button" to both button elements to ensure they are semantically correct
and properly recognized by assistive technologies.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcModeTabs.razor`:
- Around line 8-19: The entire mode tabs container in BitFcModeTabs.razor is
hidden when State.Resources.Count is zero, which traps users in Timeline mode if
resources become empty since they have no UI way to switch back to Event mode.
Remove the outer conditional check on State.Resources.Count so that the mode
tabs remain visible even when resources are empty. Keep the tabs accessible at
all times by rendering the entire div with the foreach loop over _modes and the
State.SetMode(mode) calls regardless of whether State.Resources has items.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcSettings.razor`:
- Around line 12-47: The checkbox inputs in the three dropdown items (for badge
variant toggle, time format toggle, and event layout toggle) and the number
input for day start hour lack proper accessible associations with their labels.
Add unique `id` attributes to each input element (the three checkboxes and the
number input), then update the `label` elements wrapping the checkboxes to
include `for` attributes referencing their corresponding input ids, and for the
number input that doesn't have a wrapping label, add an `aria-labelledby`
attribute that references the id of the span containing DayStartsAtLabel text to
establish the semantic relationship for screen readers.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarColorScheme.cs`:
- Around line 20-28: The constructor in BitFullCalendarColorScheme keeps a live
reference to the caller-provided options list on line 21 by directly assigning
it to the Options property, while the _byId dictionary is built only once during
construction. If the source list is mutated after construction, Options and the
_byId lookup dictionary can become inconsistent. To fix this, create a defensive
copy/snapshot of the options list (using ToList() or similar) before assigning
it to Options, ensuring that both Options and _byId always represent the same
immutable state regardless of external mutations to the original list.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFcAgendaScrollInterop.cs`:
- Line 19: The date.ToString("yyyy-MM-dd") call on the date variable is
culture-sensitive and may produce non-ASCII digits in certain locales, which
will break JavaScript date matching and parsing. Modify the ToString call to
explicitly use CultureInfo.InvariantCulture as the second parameter to ensure
the date is always formatted with ASCII digits in the yyyy-MM-dd format,
regardless of the system locale.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarChangeNotifier.cs`:
- Around line 68-82: The CloneEvent method in BitFullCalendarChangeNotifier
performs a shallow copy of the Data property by directly assigning the reference
instead of creating a deep clone, which violates the deep-snapshot contract.
Modify the Data assignment in the CloneEvent method to deep clone the
source.Data object rather than copying the reference, using an appropriate deep
cloning mechanism such as JSON serialization and deserialization to ensure
mutable objects are not shared between the original and cloned event payloads.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarState.cs`:
- Around line 178-186: The EventsMatch method is using reference equality checks
only, which means when parent components modify existing event instances without
changing the reference, SyncEvents skips the update thinking nothing changed.
Update the EventsMatch method to perform deep content-based comparison of the
event properties instead of just ReferenceEquals checks, so that mutations to
existing items are properly detected. Apply the same fix to the SyncResources
method and its corresponding ResourcesMatch comparison method to ensure
consistent behavior across both event and resource synchronization.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarDayView.razor.cs`:
- Around line 3-90: The BitFcCalendarDayView component displays current events
based on DateTime.Now but never triggers periodic re-renders, causing the
"Happening now" status to become stale during long sessions. Add a timer
mechanism in the component lifecycle (such as in OnInitializedAsync or
OnAfterRenderAsync) that periodically calls StateHasChanged() at regular
intervals (e.g., every minute) to refresh the component and keep the current
event status accurate. Ensure the timer is properly disposed in the component's
cleanup to prevent memory leaks, similar to how the scroll signature is managed
in the existing lifecycle methods.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarTimeline.razor.cs`:
- Around line 13-17: In the timer callback initialization for _timer, both
UpdatePosition() and StateHasChanged() must be wrapped inside a single
InvokeAsync call to ensure they execute on the Blazor renderer thread. Currently
UpdatePosition() is called directly on the timer thread before being marshaled,
which can cause race conditions since _positionPx is modified. Move the
UpdatePosition() call inside the InvokeAsync delegate so that both methods
execute atomically on the renderer thread, preventing state modification outside
the renderer's synchronization context.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarWeekView.razor`:
- Around line 43-47: The week time slot divs with class bit-bfc-hour-row are
currently only clickable, which excludes keyboard users. Add a keyboard event
handler by binding `@onkeydown` to a new method (OnHourSlotKeyDownAsync) that
accepts KeyboardEventArgs along with the day and hour parameters, and invoke the
existing OnHourClickAsync method when the Enter or Space keys are pressed. Apply
this keyboard handler binding to both affected div elements in the week view
grid (the ones currently showing `@onclick`="() => OnHourClickAsync(d, hour)").

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcEventBlock.razor`:
- Around line 28-35: The BitFcEventBlock event container div is not
keyboard-accessible, preventing keyboard users from activating event details.
Add the tabindex="0" attribute to the div element to make it focusable, then add
the `@onkeydown`="OnKeyDown" event binding to the same div. Implement the
OnKeyDown method that takes KeyboardEventArgs as a parameter and calls the
existing OnClick method when the user presses Enter or Space keys.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcMiniCalendar.razor`:
- Around line 15-21: The icon-only buttons for PrevMonth and NextMonth
navigation lack accessible labels for screen readers, making them inaccessible.
Add aria-label attributes to both buttons with descriptive text like "Previous
month" and "Next month" respectively. Additionally, the day selection elements
(the clickable span elements referenced at lines 43-45) need keyboard support -
convert them to button elements or add keyboard event handlers (onkeydown) to
make them accessible via keyboard navigation, ensuring they can be focused and
activated with Enter/Space keys like standard controls.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcMiniCalendar.razor.cs`:
- Around line 9-15: The `_displayMonth` field is initialized only once in
`OnInitialized()` and can become out of sync with `State.SelectedDate` when the
selected date changes externally. Override the `OnParametersSet()` lifecycle
method in the BitFcMiniCalendar component to synchronize `_displayMonth`
whenever parameters change, using the same logic that calculates `_displayMonth`
from `State.SelectedDate` as in `OnInitialized()`. This ensures `_displayMonth`
stays synchronized with external changes to the selected date.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/MonthView/BitFcDayCell.razor`:
- Around line 8-12: The clickable div elements in the BitFcDayCell component
(around line 8 with the OnCellClick handler and the additional clickable element
around line 44) do not support keyboard navigation and activation, making them
inaccessible to keyboard users. Convert these interactive divs to proper
keyboard-accessible controls by adding a tabindex attribute to make them
focusable, an ARIA role to identify them as interactive elements, and keyboard
event handlers (`@onkeydown` or `@onkeyup`) that trigger the same OnCellClick action
when Enter or Space keys are pressed, matching the click behavior.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/MonthView/BitFcMonthEventBadge.razor`:
- Around line 19-25: The BitFcMonthEventBadge component's event badge div is not
keyboard-accessible. Add tabindex="0" to the div element to make it focusable,
and add an `@onkeydown` event handler that detects Enter or Space key presses and
invokes OnSelected.InvokeAsync(Event) when those keys are pressed, matching the
behavior of the existing click handler for keyboard users.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineDayView.razor.cs`:
- Line 18: The constant _scrollContainerId in the BitFcTimelineDayView component
uses a fixed DOM id that can collide when multiple calendar instances render on
the same page. Change _scrollContainerId from a constant to an instance field
that generates a unique identifier per component instance (such as using a GUID
or unique suffix), ensuring each calendar instance has its own unique scroll
container id to prevent the scrollTimelineToTarget method from operating on the
wrong element.
- Around line 72-85: The OnSlotClickAsync method accepts a minute parameter but
discards it in the internal add flow when OnAddClick is not delegated. Store the
minute value by adding a field similar to _addStartHour (for example,
_addStartMinute), then assign the minute parameter to this field when setting
_showAddDialog to true. Next, pass this stored minute value to the
BitFcAddEditEventDialog component by updating its parameters, and ensure the
dialog component supports and respects the minute parameter when initializing
the time selection to preserve half-hour slot precision.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineEventBlock.razor.cs`:
- Around line 71-74: The catch block in BitFcTimelineEventBlock.razor.cs
currently only catches JSException, but common Blazor lifecycle exceptions like
JSDisconnectedException, InvalidOperationException, and
OperationCanceledException can also be thrown during interop calls and will
crash the render if not handled. Expand the catch clause to handle all these
exception types alongside JSException so they are properly swallowed and the
render retry logic is executed for all expected failure scenarios.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineLayout.razor`:
- Around line 23-27: The `!hasResources` conditional in
BitFcTimelineLayout.razor prevents the rendering of unassigned event rows
because the else block never executes when hasResources is false. Restructure
the logic to ensure that the unassigned-row rendering (referenced at lines
58-70) is not blocked by the !hasResources check. Either move the unassigned row
rendering outside of or before the hasResources conditional, or add a separate
condition that allows unassigned events to display independently of whether
resources exist.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineMonthView.razor.cs`:
- Line 18: The _scrollContainerId constant in BitFcTimelineMonthView is
hardcoded, causing ID collisions when multiple calendar instances are rendered.
Replace the const declaration with a property or field that generates a unique
identifier per component instance (such as using a Guid or unique prefix based
on component state), ensuring each rendered timeline month view has a distinct
scroll container id that won't conflict with other instances on the same page.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineWeekView.razor`:
- Around line 21-26: The code filters out null/empty resource IDs on line 21,
but then uses unguarded dictionary lookups with resource.Id and rowKey as keys
on lines 60, 91, and 126 without verifying they are not null or empty. Add guard
conditions before each dictionary lookup at these locations to check if the
resource ID or rowKey is null or empty, and either skip the operation or provide
a safe fallback to prevent runtime exceptions when rendering rows with invalid
resource identifiers.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineWeekView.razor.cs`:
- Line 18: The constant _scrollContainerId with a hardcoded value
"bit-bfc-tl-week-scroll" will cause id collisions when multiple calendar
instances are rendered on the same page. Replace this constant with a
per-instance field that generates a unique scroll container id for each
BitFcTimelineWeekView component instance, such as using a generated guid or
unique identifier that is assigned when the component initializes.
- Around line 74-87: The OnSlotClickAsync method receives a minute parameter but
only uses it when OnAddClick has a delegate. In the fallback branch where the
built-in add dialog is shown (lines 84-86), the minute value is ignored. Store
the minute parameter in a new field (similar to how _addStartHour stores the
hour) such as _addStartMinute, and ensure this field is set when _showAddDialog
is set to true. Additionally, verify that the BitFcAddEditEventDialog component
uses this _addStartMinute field when initializing the event time, adding support
for StartMinute if it does not currently exist.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/YearView/BitFcCalendarYearView.razor`:
- Around line 21-22: The div elements with click handlers at lines 21-22 and
40-41 in BitFcCalendarYearView.razor lack keyboard accessibility, preventing
keyboard-only users from navigating. Add keyboard event support to both div
elements by implementing an onkeydown event handler that triggers the same
action (GoToMonth call at line 21 and the day/event navigation at line 40) when
Enter or Space keys are pressed. Additionally, add appropriate ARIA attributes
(role and tabindex) to make these divs focusable and semantically indicate they
are interactive elements to assistive technologies.
- Around line 37-38: The dayEvents filter in BitFcCalendarYearView.razor uses
only StartDate.Date comparison, which excludes multi-day events from
intermediate and end dates. Modify the Where clause to check if cell.Date falls
within a date-range overlap by comparing against both the event's StartDate and
EndDate properties, ensuring a multi-day event is included on every day it
spans, not just its start date.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Styles/extra-components.scss`:
- Line 7: The stylelint rule scss/load-partial-extension is being violated in
the extra-components.scss file. Remove the explicit .scss file extension from
the `@import` statement for BitFullCalendar - the stylelint rule requires that
SCSS partials be imported without their file extension, so the import should
reference only the directory path and filename without the .scss suffix.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/FullCalendar/BitFullCalendarDemo.razor`:
- Around line 18-23: The BitLink component in BitFullCalendarDemo.razor has
Target="_blank" set to open an external link in a new tab, but it is missing the
rel attribute required for security. Add rel="noopener noreferrer" to the
BitLink component that points to the NuGet package URL to prevent
reverse-tabnabbing vulnerabilities and properly isolate the opener context when
opening external links in a new tab.

---

Minor comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcEventDetailsDialog.razor.cs`:
- Around line 19-23: The OnEditClose() method invokes the OnClose callback
asynchronously but does not await the result, which can cause the callback to
not complete properly. Change the OnEditClose() method signature from void to
async Task, and add the await keyword before the OnClose.InvokeAsync() call to
ensure the asynchronous operation completes before the method returns.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcEventListDialog.razor`:
- Line 6: In the BitFcEventListDialog.razor component's h3 element, the date
formatting using Date.ToString("dddd, MMM d, yyyy") does not respect the
calendar's culture setting. Modify the Date.ToString call to include
State.Culture as a culture parameter so that the date is formatted according to
the calendar's culture instead of the default culture. This will ensure the date
header displays in the correct localized format.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcCalendarHeader.razor`:
- Around line 20-23: The button element with the OnAddEventClick handler in
BitFcCalendarHeader.razor lacks an explicit type attribute, causing it to
default to type="submit" per HTML specification. This can trigger unintended
form submission if the FullCalendar component is placed within a form context.
Add type="button" explicitly to the button element that contains the
OnAddEventClick event handler to ensure it only calls the click handler and does
not submit any parent form.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarChangeEventArgs.cs`:
- Line 49: Add the `required` keyword to the Source property in the
BitFullCalendarChangeEventArgs class to force callers to explicitly assign a
BitFullCalendarChangeSource value, preventing silent defaults to Dialog (the
zero enum value) which can cause incorrect origin metadata in change payloads.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarEvent.cs`:
- Around line 25-27: The IsSingleDay property at line 25 of BitFullCalendarEvent
class does not treat midnight EndDate as exclusive, causing events ending at
00:00 of the next day to be incorrectly classified as multi-day. Fix this by
adjusting the Date comparison in the IsSingleDay property to subtract one tick
or unit of time from EndDate before comparing dates, ensuring that an EndDate at
midnight is treated as the end of the previous day rather than the start of the
next day.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarHelpers.cs`:
- Around line 213-218: The FormatTime method is using
CultureInfo.InvariantCulture for both the 24-hour and 12-hour time format calls,
which prevents localization for non-English cultures. Replace
CultureInfo.InvariantCulture with CultureInfo.CurrentCulture in both
date.ToString() calls within the FormatTime method to respect the user's active
culture settings. Apply the same fix to the similar time formatting code
mentioned in the "Also applies to" section around lines 248-254.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarWeekView.razor.cs`:
- Around line 36-49: The OnHourClickAsync method only calls
State.SetSelectedDate(day) when OnAddClick has a delegate, but not when using
the built-in add dialog (when _addDate, _addHour, and _showAddDialog are set).
Move the State.SetSelectedDate(day) call outside of the if block so it executes
regardless of which path is taken, ensuring the SelectedDate remains consistent
across both the delegated callback path and the built-in dialog path.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineDayView.razor`:
- Around line 60-61: The preview styling for drag operations in
BitFcTimelineDayView.razor is computed without verifying that an active drag is
in progress, allowing stale preview highlighting to persist after a drag is
canceled. Add a check to verify that a drag operation is currently active before
setting isPreviewHour and isPreviewHalf variables around lines 60-61.
Additionally, apply the same fix to the similar preview checks mentioned at
lines 95-96. The condition should verify that _dragResourceId is not null or
empty and that an active drag state exists before allowing the preview styles to
be applied.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineMonthView.razor`:
- Around line 79-80: The isPreview condition on lines 79-80 (and also on lines
106-107) only checks if the current cell matches the drag source cell, but does
not verify if an active drag operation is in progress. When a drag is cancelled,
these variables retain their values, causing stale preview highlights to remain.
Add a check for an active drag state (such as a boolean flag tracking whether a
drag is currently in progress) to the isPreview condition so that the preview
class is only applied when there is both an active drag operation and the cell
matches the drag source.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/YearView/BitFcCalendarYearView.razor`:
- Around line 8-10: Replace the hardcoded value 12 in the Enumerable.Range call
within the months variable assignment with a dynamic call to the calendar's
month count method. Instead of Range(1, 12), use Range(1,
cal.GetMonthsInYear(culturalYear)) or the appropriate equivalent method on the
cal object to retrieve the actual number of months in the given year, ensuring
the code correctly handles calendars with varying month counts.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/FullCalendar/BitFullCalendarDemo.razor`:
- Line 5: The Description attribute text in the BitFullCalendarDemo.razor
component has awkward wording and inconsistent casing. Update the Description
property to use proper casing for "FullCalendar" (currently lowercase) and
simplify the text to remove redundancy. Instead of "fullcalendar component of
the bit BlazorUI components", use clearer phrasing such as "FullCalendar
component for Bit BlazorUI" to improve readability and consistency for
user-facing documentation.

---

Nitpick comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarColorScheme.cs`:
- Around line 90-101: The GetSortOrder method in BitFullCalendarColorScheme
currently uses StringComparer.OrdinalIgnoreCase.GetHashCode() for unknown color
IDs, which is non-deterministic across process runs and doesn't implement
text-based sorting as documented. Replace the hash-based fallback on line 101
with a deterministic approach that sorts unknown IDs lexically by their string
value instead of relying on hash codes, such as computing a value based on the
ordinal character values of the trimmed string or implementing a stable
text-based comparison alternative.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcWeekViewMultiDayEventsRow.razor`:
- Around line 11-16: The FirstOrDefault call over _weekEvents is executed inside
nested loops for each day and row, causing quadratic time complexity during
rerenders. Create a precomputed lookup dictionary in the OnParametersSet
lifecycle method that maps (date, row) tuples to events based on the same
filtering criteria (checking _eventRows values and date ranges with
StartDate.Date and EndDate.Date comparisons). Then replace the FirstOrDefault
logic in the render loop with a simple O(1) dictionary lookup using the current
day and row as the key.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFcCalendarToast.razor.cs`:
- Around line 6-7: The BitFcCalendarToast component stores
CancellationTokenSource objects in the _removalTokens list but never removes
them after they are no longer needed, only cleaning them up at component
disposal. To prevent unbounded list growth on long-lived pages, remove each
CancellationTokenSource from the _removalTokens list after its associated toast
timer completes or the toast is manually dismissed. Locate where new
CancellationTokenSource instances are added to _removalTokens around line 16 and
the disposal logic at line 39, then add cleanup logic that removes the token
from the list immediately after the timeout or dismissal occurs rather than
waiting for component disposal.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.scss`:
- Line 3: Remove the .scss file extension from the import statement on line 3
where "functions.scss" is being imported, changing it to just "functions" to
comply with the scss/load-partial-extension rule. Additionally, locate the
keyframe definitions around lines 200 and 1106 in the BitFullCalendar.scss file
and rename them to follow the keyframes-name-pattern convention, which typically
requires lowercase names with hyphens rather than camelCase or other formats.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.ts`:
- Around line 104-141: The onPointerMove callback and endResize function
currently process events from any pointer instead of just the pointer that
initiated the resize operation. Add a check in the onPointerMove function to
verify that the incoming event's pointerId matches the activePointerId before
updating latestY. Similarly, in the endResize function, verify that the
triggering pointer's pointerId matches activePointerId before executing the
resize end logic. This ensures that multi-pointer input on touch or pen devices
only responds to movement and events from the pointer that started the resize
operation. Apply the same gate logic to the second occurrence of these event
handlers mentioned in the comment (lines 179-215).

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcDateTimePicker.razor.cs`:
- Around line 71-74: The OnFocusOut method unconditionally closes the panel by
setting _isOpen to false, which causes it to close prematurely when users
interact with child controls. Instead of always closing, modify the OnFocusOut
method to check whether the focus is moving to a child element within the picker
component or genuinely leaving it entirely. You can inspect the relatedTarget
property from the FocusEventArgs to determine if focus is moving to an internal
child element (in which case keep the picker open) or if it's moving outside the
component (in which case close it). Alternatively, implement a small delay
before closing to allow child click handlers to execute, then check if focus has
returned to the picker before proceeding with the close operation.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/DragDrop/BitFcDraggableEvent.razor`:
- Around line 3-8: The BitFcDraggableEvent component's interactive div element
is currently not keyboard-accessible. To fix this, add keyboard event handling
to the div by adding an `@onkeydown` event handler that triggers the same OnClick
behavior when the Enter or Space key is pressed, and add a tabindex="0"
attribute to make the div focusable for keyboard users. This ensures that
keyboard users can interact with the draggable event the same way mouse users
can through the click handler.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcSettings.razor`:
- Around line 54-63: The Agenda Group By options use non-semantic div elements
with `@onclick` handlers which are not keyboard-accessible or focusable. Replace
both div elements (the one with
SetAgendaModeGroupBy(BitFullCalendarAgendaGroupBy.Date) and the one with
SetAgendaModeGroupBy(BitFullCalendarAgendaGroupBy.Color)) with button elements
instead. Keep all the same class bindings, style bindings, and click handlers
intact, but change the element type from div to button to make them properly
focusable and keyboard-operable.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarColorOption.cs`:
- Around line 14-43: The Defaults property in the BitFullCalendarColorOption
class exposes a list of mutable objects that can be modified by consumers,
causing global side effects across all calendar instances. Make the
BitFullCalendarColorOption class immutable by converting it to a record type or
by changing the Id, Title, and Value properties to use init-only accessors
instead of set accessors. This ensures that the default color instances returned
from the Defaults property cannot be mutated after initialization.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarColorScheme.cs`:
- Around line 20-29: The snapshot of options in the BitFullCalendarColorScheme
constructor is shallow, copying only list references not the individual
BitFullCalendarColorOption objects themselves. This means if any
BitFullCalendarColorOption (especially its Id property) is mutated after
construction, the _byId dictionary will become out of sync with the Options
list. To fix this, perform a deep copy of each BitFullCalendarColorOption object
when populating the Options collection, and build the _byId dictionary from this
deep-copied Options collection to ensure the lookup and options list remain
consistent even if the original objects are mutated later.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarEvent.cs`:
- Around line 8-9: The BitFullCalendarEvent model allows invalid event ranges
where EndDate could be less than StartDate, resulting in a negative duration
calculation at line 27 that propagates to the HandleDrop method in
BitFullCalendarState and causes invalid state updates. Add validation in the
BitFullCalendarEvent class (either in property setters for StartDate and EndDate
or in a constructor) to enforce the invariant that EndDate must be greater than
or equal to StartDate, rejecting any attempt to create or update an event with
an inverted date range at the model boundary before the invalid data reaches the
drag/drop logic.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarHelpers.cs`:
- Around line 510-515: The Where clause filtering events in the day range check
is inconsistent with how GroupEventsByDayRange handles exclusive midnight
boundaries. Currently using ev.EndDate.Date treats midnight as inclusive,
causing events ending at 00:00 to appear on the next day. Modify the EndDate
logic in this Where clause (around the line with ev.EndDate.Date) to match the
exclusive-midnight handling already implemented in GroupEventsByDayRange at line
375, ensuring events ending at midnight do not appear as carry-over in
subsequent month cells.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarState.cs`:
- Around line 178-186: The SyncEvents method short-circuits when EventsMatch
returns true on lines 180-181 without calling ApplyFilters on line 184, causing
filtered events to become stale when individual event objects are mutated
in-place (such as Color or attendees changes). Remove the early return condition
or restructure the method to ensure ApplyFilters and NotifyStateChanged are
always executed, even when the event list structure matches. This same issue
also exists in the other similar code block around lines 216-227.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/AgendaView/BitFcAgendaEvents.razor`:
- Line 47: The search input element in BitFcAgendaEvents.razor lacks an
accessible label for screen readers, and the event rows referenced at lines
62-63 appear to be clickable divs rather than semantic interactive elements. Add
an associated label element (using for attribute) or aria-label to the search
input to describe its purpose, and convert the event row divs to button elements
or add proper ARIA role, tabindex, and keyboard event handlers to make them
accessible to keyboard and screen reader users.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarDayView.razor`:
- Around line 34-38: The div elements used for hourly time slots in
BitFcCalendarDayView.razor (such as the div with class "bit-bfc-hour-row
bit-bfc-droppable" and `@onclick` handler "OnHourClickAsync") lack keyboard
accessibility, preventing keyboard-only users from creating events. Convert
these div elements to semantic button elements or add appropriate ARIA
attributes (role="button", tabindex, and `@onkeydown` handlers) to enable keyboard
interaction. Apply this fix to all similar time-slot divs including those around
the mentioned lines, ensuring both mouse clicks and keyboard events (Enter/Space
keys) trigger the OnHourClickAsync method.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarWeekView.razor`:
- Around line 35-37: The current filtering logic in the Where clause for
dayEvents uses date equality checks (e.StartDate.Date == d.Date ||
e.EndDate.Date == d.Date) which fails to correctly identify overlapping events,
particularly for events spanning multiple days or with exclusive end times.
Replace this equality-based filtering with proper interval overlap logic that
checks if the event overlaps with the current day using the condition:
event.StartDate is before the day's end AND event.EndDate is after the day's
start. This ensures all events that have any overlap with the day column are
included in dayEvents for the GroupEvents operation.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/MonthView/BitFcCalendarMonthView.razor`:
- Around line 19-22: Add a `@key` directive to the BitFcDayCell component in the
foreach loop that iterates over cells to prevent Blazor from reusing component
instances by position when the month data changes. Use a unique identifier from
the cell object (such as the cell's date or a unique ID property) as the key
value to ensure each day cell maintains its own state and prevents stale UI
state like open dialogs from appearing in the wrong date cell.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/MonthView/BitFcDayCell.razor`:
- Around line 8-12: The BitFcDayCell component's interactive div element is
currently only accessible via mouse clicks. To make it keyboard-accessible, add
tabindex="0" and role="button" attributes to the div element containing the
bit-bfc-month-cell class, then add an `@onkeydown` event handler that calls a new
OnCellKeyDown method. In the BitFcDayCell.razor.cs code-behind file, implement
the OnCellKeyDown handler that checks if the pressed key is Enter or Space, and
if so, awaits the OnCellClick() method to perform the same action as the click
handler.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineWeekView.razor`:
- Around line 108-121: The div elements with classes bit-bfc-tl-cell and
bit-bfc-tl-cell-half are currently non-focusable and only respond to mouse
events (onclick, ondrop, ondragenter), preventing keyboard-only users from
interacting with them. Make these elements keyboard-accessible by either
converting them to button elements with appropriate aria-labels, or keeping them
as divs but adding tabindex="0" to make them focusable and adding keyboard event
handlers (such as `@onkeydown`) that trigger the same OnSlotClickAsync and event
handler methods when Enter or Space keys are pressed.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/YearView/BitFcCalendarYearView.razor`:
- Around line 31-38: The code is performing an expensive linear search through
all events for every cell in the year view, creating an O(cells × events)
performance bottleneck. Before the foreach loop that iterates over cells,
pre-compute a dictionary or lookup structure that maps dates to their
corresponding events from the allEvents collection. Then inside the foreach loop
in BitFcCalendarYearView.razor, replace the Where query with a simple dictionary
lookup using cell.Date.Date as the key to retrieve the dayEvents, eliminating
the per-cell scanning of all events.
- Around line 40-42: The year-day cell container (the div with class
bit-bfc-year-day) is using a clickable div element which is not
keyboard-accessible by default. To fix this in the BitFcCalendarYearView
component, replace the div with a button element (or add keyboard event handlers
like `@onkeydown` for Enter/Space keys along with tabindex="0" and appropriate
ARIA attributes if a button is not suitable). This will ensure that users can
open the ShowEventsForDay event list using keyboard navigation, making the
component fully accessible.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Styles/extra-components.scss`:
- Line 7: The import statement for BitFullCalendar includes the `.scss` file
extension, which violates the stylelint scss/load-partial-extension rule. Remove
the `.scss` extension from the import path in the statement `@import
"../Components/FullCalendar/BitFullCalendar.scss";` so that it imports the
partial without the extension, allowing Stylelint to properly validate the
import and preventing pipeline check failures.

---

Minor comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/DragDrop/BitFcDroppableArea.razor`:
- Around line 4-7: The `@ondrop` event binding in the BitFcDroppableArea component
is missing the preventDefault directive that is already applied to `@ondragover`.
Add the :preventDefault="true" modifier to the `@ondrop` binding (similar to how
it is applied to `@ondragover`) to ensure the browser's default behavior is
prevented when items are dropped on the droppable area, avoiding accidental
navigation or unwanted content handling from external drops.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcModeTabs.razor`:
- Around line 13-14: Add an explicit type="button" attribute to the button
element with class "bit-bfc-mode-tab" to prevent it from defaulting to type
submit and causing accidental form submissions when the calendar component is
placed within a form. This ensures the button only triggers the onclick handler
without submitting any parent form.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarOptions.cs`:
- Around line 16-17: The StartOfDayHour property in BitFullCalendarOptions class
lacks validation for the documented 0-16 range constraint, allowing any integer
value to be set. This causes runtime issues when the unconstrained value is
applied in BitFullCalendar.razor.cs. Add validation logic to the StartOfDayHour
property setter to enforce the 0-16 range by either clamping the value using
Math.Clamp or throwing an ArgumentException if an out-of-range value is
provided, ensuring the property contract matches its documentation.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarHelpers.cs`:
- Around line 83-87: The StartOfWeek method currently falls back to
DayOfWeek.Sunday when the culture parameter is null, instead of using the
current UI culture. Modify the startDay assignment in the StartOfWeek method to
use CultureInfo.CurrentUICulture.DateTimeFormat.FirstDayOfWeek as the fallback
instead of DayOfWeek.Sunday. This will make the method consistent with other
culture-aware methods and properly respect regional week start conventions when
no culture is explicitly provided.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarTimeline.razor.cs`:
- Around line 12-23: The Timer in the BitFcCalendarTimeline component is
configured with an initial due time of one minute, which causes the first
refresh to occur one minute after initialization rather than at the next minute
boundary. This misalignment can leave the "current time" marker behind by up to
60 seconds. Calculate the time remaining until the next minute boundary by
finding the current time's seconds and milliseconds, then subtracting from one
minute, and use this calculated TimeSpan as the dueTime parameter in the Timer
constructor instead of TimeSpan.FromMinutes(1), keeping TimeSpan.FromMinutes(1)
as the period for subsequent ticks. This ensures UpdatePosition is called at
clock minute transitions rather than arbitrary intervals.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineMonthView.razor.cs`:
- Around line 115-121: The OnAfterRenderAsync method calls
BitFcTimelineScrollInterop.TryScrollToTargetAsync on every render even when the
selected month is not the current month, resulting in unnecessary JavaScript
interop calls since there is no "today" target to scroll to in those cases. Add
a guard condition before calling
BitFcTimelineScrollInterop.TryScrollToTargetAsync that checks whether
State.SelectedDate (year and month) matches DateTime.Today (year and month), so
the interop only executes when the selected month is the current month. Keep the
existing _scrollSignature caching logic to prevent duplicate calls within the
same month.

---

Nitpick comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Enums/BitFullCalendarView.cs`:
- Around line 3-10: Add XML documentation comments to the BitFullCalendarView
enum and all its members (Day, Week, Month, Year, Agenda) to match the
documentation style and completeness of BitFullCalendarEventLayout and
BitFullCalendarMode. Include a summary comment for the enum itself explaining
its purpose as the supported calendar view types, and add brief documentation
for each enum member describing what each view represents or when it should be
used.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcEventBlock.razor`:
- Around line 40-44: The resize handles in BitFcEventBlock are only accessible
via pointer events, preventing keyboard users from resizing events. Make the
resize handles keyboard-accessible by adding tabindex="0" to make them
focusable, adding keyboard event handlers (like `@onkeydown`) alongside the
existing `@onpointerdown` handlers to respond to arrow keys or Enter, and
including appropriate ARIA attributes such as role="button" and aria-label to
describe the handle's purpose. Apply these changes to both the top resize handle
(with _topHandleId) and the bottom resize handle referenced in the "Also applies
to" comment at lines 68-72.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcMiniCalendar.razor`:
- Around line 43-45: Replace the non-semantic `<span>` element used for day
selection in the BitFcMiniCalendar component with a `<button>` element to
improve accessibility and keyboard navigation. The span element with the class
"bit-bfc-mini-calendar-day" and the `@onclick` handler for SelectDate should be
converted to a button while preserving the class binding, the onclick handler
that calls SelectDate(cell.Date), and the displayed content `@cell.Day`.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineMonthView.razor`:
- Around line 80-86: The `<div>` element with class "bit-bfc-tl-cell" is only
operable via mouse click. To make it keyboard-accessible, add the tabindex="0"
attribute to the div to make it focusable, then add an `@onkeydown` event handler
that detects Enter or Space key presses and calls the same
OnSlotClickAsync(rowKey, day) method that the `@onclick` handler uses. Apply the
same changes to all similar timeline slot cell elements throughout the component
(also at lines 107-113).

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.ts`:
- Around line 96-143: The event listeners for pointermove, pointerup, and
pointercancel are being registered after awaiting OnResizeStart, which allows a
fast pointer release to occur before the listeners are attached, causing the
endResize handler to be missed and leaving event listeners active. Move the
three addEventListener calls (for pointermove with onPointerMove, pointerup with
endResize, and pointercancel with endResize) to execute before the await of
OnResizeStart so that any pointer events are properly captured. Apply this same
ordering fix to the initResizeHorizontal function as well.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcAddEditEventDialog.razor`:
- Around line 76-78: The three input fields for attendee information
(_newFirstName, _newLastName, and _newId) lack explicit labels or aria-label
attributes, making them inaccessible to screen readers. Add aria-label
attributes to each of these input elements that describe the field's purpose
using the corresponding localized text from the Texts resource
(FirstNamePlaceholder, LastNamePlaceholder, and IdOptionalPlaceholder). This
ensures screen reader users can understand what information each field expects
without relying solely on visual placeholders.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcDateTimePicker.razor`:
- Around line 14-18: The aria-label attributes on the navigation buttons (lines
14 and 18) in BitFcDateTimePicker.razor are hard-coded with English text,
preventing localization based on the selected culture. Add two new string
parameters named PreviousMonthAriaLabel and NextMonthAriaLabel to the
component's code-behind (BitFcDateTimePicker.razor.cs) with appropriate default
English values, then bind these parameters to the respective aria-label
attributes in the Razor markup by replacing the hard-coded strings with property
bindings.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcEventListDialog.razor`:
- Around line 12-23: The event row in BitFcEventListDialog.razor is currently
only mouse-clickable and inaccessible to keyboard users. The div with class
"bit-bfc-agenda-item" needs to be made keyboard-operable by adding a tabindex
attribute to make it focusable, and adding a keyboard event handler (such as
`@onkeydown`) that triggers the SelectEvent method when the user presses Enter or
Space keys. This ensures both mouse and keyboard users can select events from
the dialog.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcModeTabs.razor`:
- Around line 8-20: The guard condition at the start of the BitFcModeTabs
component hides the entire mode tabs container when there are no resources,
which removes the Event mode switching UI entirely. Instead of conditionally
rendering the entire div based on resource count, you should keep the mode tabs
container always visible and conditionally filter or render only the
Timeline-specific mode from the _modes collection when resources are available.
This way the Event mode tab remains accessible for users to switch between modes
even when the resources list is empty.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcSettings.razor.cs`:
- Around line 11-12: The SetStartOfDayHour method is being called with an
unclamped parsed value, which bypasses min/max validation that only exists on
the input element. After successfully parsing the value into the variable val
using int.TryParse, clamp val to the appropriate valid range (e.g., 0-23 for
hours) before passing it to State.SetStartOfDayHour to ensure the state
invariant is enforced at the handler level regardless of input element
constraints.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcViewTabs.razor`:
- Around line 9-10: The button element in BitFcViewTabs.razor does not have an
explicit type attribute, which causes it to default to type="submit" when inside
a form, potentially triggering unwanted form submissions. Add the type="button"
attribute to the button element that has the class "bit-bfc-view-tab" and the
onclick handler that calls State.SetView(view) to ensure it functions as a
regular button rather than a submit button.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarHelpers.cs`:
- Around line 201-210: The GetEventsForYear method in BitFullCalendarHelpers
treats EndDate.Date as inclusive in its overlap comparison, but this causes
inconsistency with the exclusive-end convention used elsewhere where midnight is
treated as the boundary. Fix the comparison logic in the where clause for
GetEventsForYear to treat EndDate as exclusive by changing the condition from
ev.EndDate.Date >= yearStart to ev.EndDate > yearStart. Apply this same
exclusive-end rule consistently across all other related date-overlap helper
methods mentioned in the comment (at lines 468-471, 578-588, 591-597, 599-609)
to ensure events ending at midnight do not incorrectly appear in the next
period.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarWeekView.razor`:
- Around line 43-47: The clickable div element in the BitFcCalendarWeekView
component that handles the `@onclick`="() => OnHourClickAsync(d, hour)" event is
not keyboard accessible. To fix this, add a role="button" attribute to indicate
this element is interactive, add tabindex="0" to make it focusable for keyboard
navigation, and add an `@onkeydown` event handler that triggers OnHourClickAsync
when the Enter or Space keys are pressed to allow keyboard-only users to create
events from the week grid view.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcMiniCalendar.razor`:
- Around line 43-45: Replace the span element with role="button" in the
BitFcMiniCalendar component with a native button element for proper keyboard
semantics. Change the span that contains the SelectDate click handler and
OnDayKeyDown keyboard handler to a button element. Remove the role="button",
tabindex="0" attributes and the `@onkeydown` handler since native buttons
automatically handle keyboard interactions like Space and Enter. Keep the class
attribute with bit-bfc-mini-calendar-day and the `@onclick` handler bound to
SelectDate(cell.Date).

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/MonthView/BitFcDayCell.razor`:
- Around line 47-49: The div element with class "bit-bfc-month-more" in
BitFcDayCell.razor is not keyboard-accessible because it only responds to click
events. Add an `@onkeydown` event handler to this div that calls a new
OnMoreKeyDown method, which should check if the pressed key is Enter, Space, or
Spacebar and set _showEventList to true when triggered. Additionally, add
tabindex="0" and role="button" attributes to the div to make it focusable and
semantically correct for keyboard users.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/MonthView/BitFcMonthEventBadge.razor`:
- Around line 47-50: The time display in the MonthView badge incorrectly shows
Event.StartDate for all positions, including when Position is "last". For
multi-day events, the last segment should display Event.EndDate instead of
Event.StartDate to correctly represent the trailing day's time. Modify the
condition that checks showTime to conditionally use either Event.EndDate when
Position equals "last" or Event.StartDate otherwise, passing the appropriate
date value to the BitFullCalendarHelpers.FormatTime method.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineDayView.razor`:
- Around line 16-19: The code filters out resources with empty IDs on line 17
when grouping events using `Where(id => !string.IsNullOrEmpty(id))`, but the
same filtering is not applied when rendering rows and drop targets around line
55 where raw `resource.Id` values are used directly. This inconsistency causes
resources with empty IDs to render but fail to retain dropped or created events
properly since the BitFullCalendarEvent.Resource contract treats empty IDs as
unassigned. Apply the same empty ID filtering logic when iterating through
resources for row and drop target rendering to ensure consistency between the
grouping logic and the rendering logic.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineEventBlock.razor.cs`:
- Around line 78-83: In the `OnResizeStart` method in
BitFcTimelineEventBlock.razor.cs, instead of storing a direct reference to the
Event object in `_resizeBaseEvent`, capture an immutable copy or deep clone of
the Event object to preserve its pre-resize state. This ensures that when
`State.UpdateEvent(updated)` is called later and the original Event object is
mutated, the `_resizeBaseEvent` will still contain the original unmodified state
needed for building the accurate `OldEvent` property. Apply the same fix to the
corresponding resize end handler method that also uses `_resizeBaseEvent` to
construct `OldEvent`.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineMonthView.razor.cs`:
- Around line 119-124: The year and month comparison in the conditional check
within the method is using Gregorian calendar properties directly
(State.SelectedDate.Year and State.SelectedDate.Month), but the rendered
calendar may use a different calendar system based on the active culture.
Replace the direct Year and Month property comparisons with culture-aware date
comparison that respects the calendar system being used for rendering, ensuring
that the scroll-to-today functionality works correctly for non-Gregorian
calendar cultures.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/YearView/BitFcCalendarYearView.razor`:
- Around line 44-46: The clickable div element with `@onclick` handler for
GoToMonth month navigation is not keyboard-accessible. Replace the div element
with a button element to make it keyboard-operable by default, which will allow
users to navigate using Tab and Enter keys. The button should maintain the same
click handler `@onclick`="() => GoToMonth(monthDate)" and display the monthName
content.

---

Nitpick comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/DragDrop/BitFcDroppableArea.razor.cs`:
- Around line 15-16: The OnDragOver method continuously sets _isOver to true
every time the ondragover event fires, causing unnecessary re-renders even when
the value is already true. Add a guard condition in the OnDragOver method to
check if _isOver is already true before assigning the value, so that a re-render
is only triggered when the state actually transitions from false to true.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcSettings.razor`:
- Around line 4-10: The button element in BitFcSettings.razor that toggles the
dropdown menu is missing accessibility attributes. Add the aria-expanded
attribute to the button and bind it to the _open variable to expose the expanded
state to screen readers, add an id attribute to the div with class
bit-bfc-dropdown-menu to uniquely identify it, and add the aria-controls
attribute to the button to establish the relationship between the button and the
dropdown menu it controls by referencing the dropdown menu's id.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarChangeNotifier.cs`:
- Around line 68-82: The CloneEvent method's XML documentation claims to create
a deep snapshot, but the Data property on Line 81 is copied by reference rather
than being deep-cloned, making the documentation misleading. Either implement
deep-cloning logic for the Data property assignment in the CloneEvent method to
match the documented behavior, or revise the XML documentation summary to
accurately describe that this method creates a shallow copy of the event with
reference-type properties like Data and Attendees being copied by reference
rather than cloned.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcDateTimePicker.razor.cs`:
- Around line 21-32: The OnParametersSet method currently only reinitializes
_visibleMonthAnchor when the Value parameter changes, but does not account for
culture or calendar changes. To fix this, track the current culture or calendar
system similar to how _lastSyncedDate is tracked, and modify the OnParametersSet
method to reinitialize _visibleMonthAnchor not only when Value changes but also
when the culture or calendar system changes. This ensures that month anchoring
remains correct when switching between different calendar systems while
maintaining the same date value.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcSettings.razor`:
- Around line 4-9: The button element in BitFcSettings component uses a
hardcoded ID "bit-bfc-settings-menu" in the aria-controls attribute, and the
menu div also uses the same hardcoded id. When multiple calendar instances exist
on the same page, this creates duplicate IDs which breaks accessibility by
causing assistive technology to point to the wrong menu. Generate a unique
identifier for each BitFcSettings component instance (typically using Guid in
the code-behind section) and replace both the aria-controls attribute on the
button and the id attribute on the menu div to use this generated unique ID
instead of the hardcoded string.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcTodayButton.razor`:
- Line 3: The button element in BitFcTodayButton.razor with the onclick handler
State.GoToToday and classes bit-bfc-btn bit-bfc-btn-sm is missing an explicit
type attribute. Add type="button" to the button element to ensure it never
accidentally submits a parent form when clicked.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarAttendee.cs`:
- Around line 15-17: The Initials property getter assumes FirstName and LastName
are non-null strings, which can cause null reference exceptions when these
properties are externally assigned null values. Add null checks before accessing
the Length property on FirstName and LastName in the Initials getter. Use the
null-coalescing operator or conditional checks to ensure that null values are
safely handled, treating them as empty strings when determining the initials.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarHelpers.cs`:
- Around line 213-218: The FormatTime method uses CultureInfo.InvariantCulture
for date formatting, which prevents localized time strings (particularly AM/PM
indicators) from respecting the user's UI culture settings. Replace
CultureInfo.InvariantCulture with CultureInfo.CurrentUICulture in both toString
calls within the FormatTime method to ensure time formatting respects the user's
locale. Additionally, apply the same fix to the similar code at lines 248-254
that handles the same formatting issue.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarState.cs`:
- Around line 48-52: The SetCulture method updates the Culture property and
calls UpdateUI() but fails to notify listeners about date-range changes. When
culture changes, the date range representation may change due to locale-specific
formatting, so consumers listening for range changes miss required updates. Add
a call to NotifyDateRangeChanged() after the UpdateUI() call in the SetCulture
method to ensure all listeners are properly notified of the date-range change.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarTimeline.razor.cs`:
- Line 3: The BitFcCalendarTimeline class has a Dispose() method defined on line
37 but does not implement the IDisposable interface on the class declaration on
line 3. Update the class declaration to implement IDisposable so that Blazor
will automatically call the Dispose() method when the component is destroyed,
ensuring the timer resource is properly cleaned up and doesn't leak.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcEventBlock.razor.cs`:
- Around line 66-76: The catch block in the resize initialization section of
BitFcEventBlock only catches JSException, but other exceptions like
JSDisconnectedException, InvalidOperationException, and
OperationCanceledException can occur during Blazor teardown and disconnect
scenarios. Update the catch block that surrounds the JS.InvokeVoidAsync calls
for "BitBlazorUI.FullCalendar.initResize" (in the OnAfterRenderAsync method) to
catch all these exception types together, aligning the exception handling
pattern with the equivalent implementation in BitFcTimelineEventBlock.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineEventBlock.razor`:
- Around line 40-47: The div element in the BitFcTimelineEventBlock component is
not keyboard-accessible because it lacks focus capability and keyboard event
handling. Make the event block keyboard-activatable by adding a tabindex
attribute to make the div focusable, adding an onkeydown event binding to the
div element, and implementing the corresponding OnKeyDown method that checks if
the pressed key is Enter, Space, or Spacebar before invoking the same OnClick
handler used for mouse clicks.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineMonthView.razor`:
- Around line 80-85: The timeline month slot cells in the BitFcTimelineMonthView
component (the div elements with classes bit-bfc-tl-cell bit-bfc-tl-cell-day at
lines 80-85 and 107-112) currently only respond to mouse interactions through
onclick handlers. To make these cells keyboard-operable, add keyboard event
handlers (`@onkeydown` or similar) to the div elements that trigger the same
OnSlotClickAsync method when the Enter or Space keys are pressed. This will
enable users to create events using keyboard navigation without requiring a
mouse, improving accessibility.

---

Duplicate comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcSettings.razor.cs`:
- Around line 11-12: The handler for the start-hour input does not validate that
the parsed value falls within the valid 0-16 range before forwarding it to
State.SetStartOfDayHour. After successfully parsing the value with int.TryParse,
clamp the parsed integer val to ensure it stays within bounds (minimum 0,
maximum 16) before passing it to the SetStartOfDayHour method call.

---

Nitpick comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.razor.cs`:
- Around line 199-210: The ApplyOptions method uses ReferenceEquals to compare
Options with _appliedOptions, which only detects changes when a completely new
Options object is assigned, not when individual properties are modified on the
existing instance. To fix this, implement a version tracking mechanism or
hash-based comparison that can detect property changes within the same Options
object. You could add a version property to the Options class that increments
when properties change, or compute a hash of the Options properties and compare
that instead of just the reference. Store the computed hash or version in
_appliedOptions alongside or in place of the Options reference, then check if
the current hash/version differs from the stored one in the ApplyOptions method.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineWeekView.razor.cs`:
- Around line 100-107: Add a defensive guard clause at the beginning of the
OnDrop method to check State.IsDragging, returning early if it is false. This
ensures consistency with the defensive pattern used in OnDragEnter
implementations and prevents unnecessary notifier calls when dragging is not
actually in progress.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcSettings.razor`:
- Line 4: The button element in BitFcSettings.razor that toggles the _open state
is missing an explicit type attribute, which causes it to default to
type="submit" and can unintentionally submit a parent form. Add type="button" to
the button element with the `@onclick`="() => _open = !_open" handler to prevent
form submission behavior and explicitly declare that this is a regular button
control.
- Around line 12-37: The three toggle setting rows use non-semantic `<div>`
elements with `@onclick` handlers instead of proper button controls, making them
inaccessible via keyboard and screen readers. Replace each `<div
class="bit-bfc-dropdown-item">` element (the ones containing SetBadgeVariant,
ToggleTimeFormat, and ToggleEventLayout handlers) with `<button type="button">`
elements, preserving the existing `@onclick` handlers and all internal content
including the span labels and toggle markup. This ensures keyboard navigation
and proper semantic accessibility.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineDayView.razor.cs`:
- Around line 97-104: The OnDrop method is calling HandleResourceDropAsync
unconditionally, but it should only do so when a drag operation is actually
active. Before calling the Notifier.HandleResourceDropAsync method in OnDrop,
add a guard condition to check if an active drag state exists (such as verifying
that _dragResourceId is not null before the reset). If no drag is active, the
method should return early without processing the drop logic, making it
consistent with the week view implementation.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineLayout.razor`:
- Around line 25-30: The condition checking `!hasResources` at line 25 prevents
the unassigned timeline row from rendering when resources are empty. Modify the
logic to show the empty state message only if both resources are empty AND there
are no unassigned rows to display. When resources are empty but
`HasUnassignedRow` is true or `UnassignedRowContent` exists, render the
unassigned timeline row instead of the no-resources message. Apply the same fix
to the related section at lines 60-72 to ensure consistent behavior throughout
the BitFcTimelineLayout component.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineMonthView.razor.cs`:
- Around line 111-119: The OnDrop method in BitFcTimelineMonthView.razor.cs is
missing a drag-state precondition check at the start of the method. Add a guard
clause at the beginning of the OnDrop method that checks if drag mode is active
(validate that _dragResourceId and _dragDay are not null) and returns early if
drag is not active, matching the behavior implemented in the timeline week view.
This check should occur before clearing the drag state variables and calling
HandleResourceDropAsync.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/FullCalendar/BitFullCalendarDemo.razor`:
- Line 5: The Description attribute in the BitFullCalendarDemo.razor file
contains inconsistent casing that makes it appear unprofessional and awkward for
users. Update the Description property value to properly capitalize component
names: change "fullcalendar" to "FullCalendar" and "bit BlazorUI" to "Bit
BlazorUI". Consider also improving the overall phrasing to be more polished and
user-facing, such as emphasizing that this is a powerful calendar component
within the Bit BlazorUI library rather than just stating it is a component of
it.

---

Duplicate comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.scss`:
- Line 3: The import statement for the functions.scss partial includes the file
extension, which violates the scss/load-partial-extension stylelint rule. Remove
the .scss extension from the import path in the `@import` statement that
references ../../../Bit.BlazorUI/Styles/functions.scss, so the partial is
imported without its extension as per SCSS conventions.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarEvent.cs`:
- Around line 8-9: The BitFullCalendarEvent model's StartDate and EndDate
properties do not validate that EndDate is greater than or equal to StartDate,
which allows negative durations to be calculated and propagated to downstream
logic. Add validation logic to the EndDate property setter to ensure it is never
set to a value less than the current StartDate value, and similarly validate the
StartDate property setter to ensure it is never set to a value greater than the
current EndDate value. This will prevent invalid inverted date ranges from being
created at the model boundary and protect the duration calculations and event
manipulation logic downstream.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarState.cs`:
- Around line 181-186: The SyncEvents method currently returns early when
EventsMatch(events) is true, but this optimization causes _filteredEvents to
become stale when individual event properties are mutated in-place (such as
Color or Attendees changes on shared event instances). Remove the early return
condition and the EventsMatch check so that ApplyFilters() and
NotifyStateChanged() are always executed, ensuring that any in-place mutations
to event properties trigger filter recomputation. Apply the same fix to the
similar code block mentioned in the comment (lines 217-227) to ensure consistent
behavior across all event synchronization paths.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarTimeline.razor.cs`:
- Line 3: The BitFcCalendarTimeline class has a Dispose() method defined but
does not implement the IDisposable interface. This prevents Blazor from reliably
calling the cleanup method, allowing the timer to outlive the component. Add the
IDisposable interface implementation to the BitFcCalendarTimeline class
declaration so that the existing Dispose() method is properly recognized and
invoked during component lifecycle cleanup.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineWeekView.razor`:
- Around line 108-126: The timeline week view cells in
BitFcTimelineWeekView.razor are not keyboard accessible like they are in
BitFcTimelineMonthView.razor. Add keyboard support to both the outer cell div
with class "bit-bfc-tl-cell" and the inner cell-half div with class
"bit-bfc-tl-cell-half" by adding three attributes to each: role="button" to
provide semantic meaning, tabindex="0" to make them focusable, and `@onkeydown`
event handler that calls the same OnSlotClickAsync method as the `@onclick`
handler (with the same rowKey, day, hour, and minute parameters). Apply the same
fix to both occurrences in the week view at the specified line ranges and also
to the same cells in the UnassignedRowContent section at lines 151-165.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Styles/extra-components.scss`:
- Line 7: The import statement in the extra-components.scss file includes the
.scss file extension on the BitFullCalendar.scss import, which violates the
scss/load-partial-extension Stylelint rule. Remove the .scss extension from the
import path so it matches the pattern used by other imports in the file,
changing the import to reference just the module name without the extension.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.ts`:
- Around line 307-312: Guard the storage helpers in BitFullCalendar against
DOMException by wrapping getLocalStorage and setLocalStorage in try/catch, since
localStorage.getItem/setItem can throw when storage is blocked or unavailable.
Update getLocalStorage to return null on failure and make setLocalStorage a
no-op on failure so the JS interop path degrades cleanly without breaking
preference initialization.
- Around line 207-213: Serialize resize sessions per event instead of per handle
by moving the active-resize guard in BitFullCalendar.ts from the element-local
pointer flag to a shared per-dotNetRef tracker, since
BitFcTimelineEventBlock.razor.cs wires both handles to the same dotNetRef.
Update the pointerdown/pointermove/pointerup flow in the resize logic so only
one resize can run at a time for a given event across both handles, and ensure
the shared tracking is cleared after resize end/cancel.
- Around line 130-159: The async resize lifecycle in FullCalendar can still
surface unhandled promise rejections because `endResize` is used directly as a
DOM listener and also replayed from the deferred `pointerdown` flow. Update the
listener entry points around `endResize`, the deferred replay path, and the
related resize handlers mentioned in the comment to use non-async wrappers that
call the async work via `void ...catch(...)`, while keeping the existing cleanup
and `OnResizeMove`/`OnResizeEnd` sequencing intact.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcAddEditEventDialog.razor.cs`:
- Around line 138-185: The Submit flow in BitFcAddEditEventDialog is re-entrant
and can be invoked twice before the dialog closes, causing duplicate add/edit
operations. Add an _isSubmitting guard inside Submit so repeated clicks/Enter
return early while a save is in progress, and make sure the flag is set before
the event/state update work and cleared afterward. Also wire the primary action
in this dialog to respect that flag so the save button is disabled during the
in-flight Submit path.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcViewTabs.razor`:
- Around line 3-13: The view switcher in BitFcViewTabs should expose the
selected state to assistive technologies. Update the container in the tabs
markup to behave like a tablist, and give each button in the `@foreach` over
_views a tab role plus an aria-selected state based on State.View == view, or
refactor to reuse an existing tabs component with the same semantics. Keep the
existing click behavior via State.SetView(view) and preserve the timeline
filtering logic.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarState.cs`:
- Around line 80-97: SetMode in BitFullCalendarState currently always calls
NotifyDateRangeChanged after updating Mode and possibly clamping View, which can
trigger OnDateChange even when the visible date range did not change. Update the
SetMode flow to compare the previously reported range against the new
Start/End/View state and only invoke NotifyDateRangeChanged when that range
actually differs, keeping the visible-range callback behavior aligned with the
BitFullCalendar.razor.cs contract.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarDayView.razor`:
- Around line 34-42: The hour slot div in BitFcCalendarDayView.razor behaves
like a button, but the current OnHourKeyDownAsync key handler still allows Space
to scroll the page. Update the keyboard handler binding on the pseudo-button
element to use a prevent-default modifier so Space activates the slot without
page scrolling, while keeping the existing OnHourKeyDownAsync behavior intact.
- Around line 8-9: The “Happening now” list in BitFcCalendarDayView only uses
SingleDayEvents, so multi-day events are missed while still active. Update the
currentEvents selection logic in the day view to include any in-progress events
from the multi-day events source as well as single-day events, using the
existing DateTime.Now range check against StartDate and EndDate. Keep the change
localized to the currentEvents computation in BitFcCalendarDayView so the
sidebar shows all currently ongoing events.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/MonthView/BitFcDayCell.razor`:
- Around line 8-15: The month day cell in BitFcDayCell is incorrectly exposed as
a full button-like container while it also hosts separate interactive controls
such as BitFcMonthEventBadge and the “more events” trigger, causing nested
interactive semantics. Update the DayCell markup and related click/keyboard
handlers so the outer cell is just a non-button container, and move the
add-event action to a dedicated control or overlay that is separately focusable
and clickable. Make the same accessibility/interaction adjustment in the other
affected sections of BitFcDayCell where the cell wrapper currently behaves like
a button.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineEventBlock.razor.cs`:
- Around line 66-80: The resize initialization in OnAfterRenderAsync can
partially succeed, leaving one handle registered while _resizeInitialized
remains false, which causes duplicate listeners on later renders. Update
BitFcTimelineEventBlock.razor.cs so the start and end handle initialization in
BitBlazorUI.FullCalendar.initResizeHorizontal is tracked separately or marked as
initialized per handle, and only retry the missing side instead of
re-registering both when one call has already succeeded. Keep the existing
exception handling, but ensure partial success does not reattach listeners on an
already-initialized handle.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/YearView/BitFcCalendarYearView.razor`:
- Around line 68-77: The year-day button content in BitFcCalendarYearView
currently includes an invalid block-level wrapper inside the button, so update
the button’s children to use valid button content only. In the year-day
rendering block that contains ShowEventsForDay and the bit-bfc-year-day-bullets
markup, replace the inner div with inline-compatible content or a span-based
wrapper so the button remains semantically valid and accessible.

---

Duplicate comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFcCalendarBody.razor.cs`:
- Around line 3-35: BitFcCalendarBody currently unsubscribes in Dispose() but
never declares IDisposable, so Blazor won’t invoke teardown cleanup. Update the
BitFcCalendarBody component type to implement IDisposable, keeping the existing
Dispose() method so State.OnStateChanged is unsubscribed when the component is
disposed. Ensure the change is applied on the BitFcCalendarBody partial class
alongside OnInitialized, Refresh, and ComputeEvents.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Header/BitFcCalendarHeader.razor.cs`:
- Line 3: The component class BitFcCalendarHeader currently defines a Dispose()
cleanup method but does not implement IDisposable, so Blazor will not
automatically call it; update the class declaration to implement IDisposable and
keep the existing Dispose logic so the State.OnStateChanged subscription is
always removed. Verify the disposal pattern around BitFcCalendarHeader and its
Dispose method remains intact, and ensure any related subscription setup in the
component is matched by the IDisposable cleanup path.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarEvent.cs`:
- Around line 8-9: BitFullCalendarEvent currently allows an invalid range where
EndDate is earlier than StartDate, which can produce a negative Duration and
later break event rebuilding in BitFullCalendarState. Add validation at the
model boundary by enforcing the StartDate/EndDate invariant in the
BitFullCalendarEvent property setters or a shared validator, and reject or
normalize any inverted range before the object can be used downstream.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcMiniCalendar.razor.cs`:
- Line 10: The mini-calendar sync key only tracks CultureInfo.Name, so it can
miss changes where the culture name stays the same but State.Culture.Calendar
changes and month normalization becomes stale. Update the sync tracking in
BitFcMiniCalendar to include the calendar implementation alongside the culture
name, and use that expanded key wherever _lastSyncedCultureName is compared or
assigned so the sync logic reruns when the calendar type changes.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/MonthView/BitFcMonthEventBadge.razor`:
- Around line 17-24: The accessible name built in BitFcMonthEventBadge.razor via
badgeAriaLabel only includes the event title and times, so update that label to
also include the start and end dates for Event.StartDate and Event.EndDate,
using the existing BitFullCalendarHelpers formatting patterns and
State.Culture/State.Use24HourFormat. Keep the aria-label on the badge element in
sync so multi-day and overnight events are announced with both dates and times.

---

Nitpick comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarHelpers.cs`:
- Around line 470-473: The midnight-exclusive end-date normalization is
duplicated across the overlap helpers, so extract that logic into a single
shared helper in BitFullCalendarHelpers and use it wherever ev.EndDate is
adjusted. Update the overlap checks that currently inline the AddTicks(-1) and
Date handling so they all call the same helper, keeping IsSingleDay,
GroupEventsByDayRange, and the other overlap methods consistent.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarState.cs`:
- Line 33: The drag state in BitFullCalendarState is too exposed because
DraggedEvent can be set directly, bypassing StartDrag and EndDrag and skipping
NotifyStateChanged. Make the DraggedEvent setter private so only the state
transition methods control it, and keep all drag mutations routed through
StartDrag/EndDrag to preserve consistent notifications.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFcCalendarToast.razor`:
- Around line 4-8: The toast list rendering in BitFcCalendarToast.razor should
key each rendered toast by its stable Id so Blazor does not reuse DOM nodes when
_toasts is mutated. Update the foreach that renders each toast div to add an
`@key` using toast.Id, keeping the existing role/class logic in the same
BitFcCalendarToast.razor markup.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.scss`:
- Around line 144-151: The button group separators in the FullCalendar styles
are using a physical right border, which breaks RTL alignment; update the
.bit-bfc-btn-group and .bit-bfc-btn:last-child rules to use a logical inline-end
border instead of border-right so the divider stays between buttons in both
directions. Keep the existing selector structure in BitFullCalendar.scss and
adjust the border removal for the last button to match the logical property.
- Around line 681-684: The timeline resize preview is hard-coded to the left in
the .bit-bfc-timeline-event-resizing.bit-bfc-resize-dir-start
.bit-bfc-resize-preview rule, so it appears on the wrong side in RTL. Update the
FullCalendar SCSS so the start-edge preview is positioned using direction-aware
styling in the timeline resize styles, keeping the preview aligned with the
actual start edge for both LTR and RTL. Use the existing
.bit-bfc-timeline-event-resizing, .bit-bfc-resize-dir-start, and
.bit-bfc-resize-preview selectors to locate and adjust the rule.

In `@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.ts`:
- Around line 156-158: The resize lock is being released too early in
`initResizeVertical`, allowing another resize to start before `OnResizeEnd`
finishes. Move the `activePointerId`/`activeKey` reset to after the awaited
`dotNetRef.invokeMethodAsync("OnResizeEnd")`, and apply the same change in
`initResizeHorizontal` so both resize paths keep the guard held until
finalization completes.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcAddEditEventDialog.razor`:
- Around line 24-31: The start/end field labels are only visual in
BitFcAddEditEventDialog and are not associated with the focusable picker trigger
rendered by BitFcDateTimePicker. Update the dialog so the picker button is
explicitly tied to `@Texts.StartDateTimeLabel` and `@Texts.EndDateTimeLabel`, using
the picker’s accessible labeling/trigger props or a generated id from the label
element, so assistive tech announces the field name along with the current
value.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcDateTimePicker.razor.cs`:
- Around line 72-78: SelectDate in BitFcDateTimePicker is updating Value and
_lastSyncedDate but not re-anchoring the calendar when a muted overflow day from
a neighboring month is chosen. Update the SelectDate flow so it also sets
_visibleMonthAnchor to the month of the selected date before closing the picker,
ensuring OnParametersSet does not keep reopening on the old month after a
cross-month selection.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Dialogs/BitFcEventListDialog.razor`:
- Around line 12-23: The event-row markup in BitFcEventListDialog should be kept
valid by removing block-level children from the button. Update the button
content inside the event list rendering to use span-level elements instead of
div wrappers, and preserve the existing layout/spacing through CSS classes or
styles rather than nested div structure. Use the SelectEvent,
BitFullCalendarHelpers.FormatTime, and ColorScheme.GetColorStyle sections as the
locations to update.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarEvent.cs`:
- Line 5: The month layout currently relies on raw event ids, so blank or
duplicate values from BitFullCalendarEvent.Id can overwrite each other in
BitFullCalendarHelpers.CalculateMonthEventPositions and GetMonthCellEvents. Add
ingestion-time normalization in the event pipeline before layout state is built
so every event has a stable unique key, and reject or remap duplicate/missing
ids instead of allowing string.Empty to flow into the dictionary keys used for
month positioning.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Services/BitFullCalendarState.cs`:
- Line 12: BitFullCalendarState is using DateTime.Today for SelectedDate and
GoToToday, which can resolve to the server’s date instead of the user’s
browser-local date in Blazor Server. Update BitFullCalendarState to accept a
browser-local “today” value from the caller (for both the initial SelectedDate
and GoToToday), and replace the direct DateTime.Today usage in the
constructor/state initialization and today-navigation path with that
injected/local date source.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcCalendarDayView.razor`:
- Around line 36-54: The lower half-slot in BitFcCalendarDayView.razor is only
wired for drag/drop, so clicks and keyboard activation on that area still bubble
to the parent hour row and call OnHourClickAsync(hour), creating :00 events.
Update the hour-cell handling around the hour row and the nested half-slot so
the 30-minute slot has its own click/keydown target and invokes the existing
hour creation flow with minute 30, while preventing the parent OnHourClickAsync
from firing for that interaction.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcMiniCalendar.razor`:
- Around line 45-47: The day button in BitFcMiniCalendar.razor currently exposes
only the day number through the button content, which makes repeated dates
indistinguishable to assistive technologies. Update the button in the
mini-calendar day cell to include an aria-label with a culture-formatted full
date derived from the same cell.Date used by SelectDate, while keeping the
visible `@cell.Day` text unchanged. Use the existing day button markup in
BitFcMiniCalendar and apply the accessible name directly on that button element.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcMiniCalendar.razor.cs`:
- Around line 39-42: The StartOfDisplayMonth method in BitFcMiniCalendar should
preserve the source era when normalizing the date, because using the era-less
ToDateTime overload can select the wrong era or fail for era-based calendars.
Update the DateTime construction to use the calendar era from cal.GetEra(date)
together with the existing cal.GetYear(date) and cal.GetMonth(date) values so
the month is rebuilt in the same era as the input date.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcRenderGroupedEvents.razor`:
- Around line 14-35: The current overlap calculation in
BitFcRenderGroupedEvents.razor uses all intersecting lanes to derive depth,
which overcounts staggered conflicts. Update the grouped-events width logic
around the leftConflicts/rightConflicts and depth/rank computation so it
measures the peak number of simultaneous overlaps within ev’s own time range,
not just whether a lane intersects at any point. Keep the existing grouping
structure, but replace the lane-count approach with a concurrency-based
calculation that still feeds depth and rank for rendering.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/YearView/BitFcCalendarYearView.razor`:
- Around line 68-78: The year-day button in BitFcCalendarYearView currently
exposes only the day number, which is ambiguous across the month grid. Update
the button in the year-view day cell rendering to include a culture-aware
full-date aria-label based on the cell’s date, while keeping the existing click
behavior in ShowEventsForDay and the visible day number unchanged. Use the day
cell rendering logic around cell.Date, cell.Day, and dayEvents to generate the
accessible name for each button.

In
`@src/BlazorUI/Demo/Client/Bit.BlazorUI.Demo.Client.Core/Pages/Components/Extras/FullCalendar/BitFullCalendarDemo.razor`:
- Around line 141-146: The FullCalendar bound example is mixing initial-only
defaults with two-way bound values, so the default attributes never take effect.
In BitFullCalendarDemo.razor, remove the DefaultView, DefaultMode, and
DefaultDate attributes from the same BitFullCalendar usage that binds View,
Mode, and Date, and keep the bound properties as the single source of truth for
this demo snippet.

---

Duplicate comments:
In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Models/BitFullCalendarResource.cs`:
- Line 14: Reject blank resource IDs by validating BitFullCalendarResource.Id
beyond the current required modifier. Add input validation in
BitFullCalendarResource so empty or whitespace-only values are not accepted, and
ensure any creation/mapping path using Id enforces a non-blank value. This
should align with BitFullCalendarState.HandleDrop, which already treats null and
empty as unassigned, so the fix should prevent blank Ids from reaching that flow
and being misinterpreted as a valid resource reference.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/DayWeekView/BitFcWeekViewMultiDayEventsRow.razor`:
- Line 23: The `BitFcWeekViewMultiDayEventsRow` rendering is still keying
`BitFcMonthEventBadge` by `ev.Id`, which can cause duplicate/missing-child
diffing when same-day events share an ID. Update the `@key` in this loop to use
a per-instance stable key from the event row context (matching the safer
`_eventRows` approach) so each badge remains uniquely identified even when
`ev.Id` collides.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineDayView.razor`:
- Around line 17-18: The timeline day view is conflating a synthetic fallback
row with real unassigned resource lanes, which can break empty-calendar
rendering. Update BitFcTimelineDayView.razor to normalize resource IDs the same
way as BitFcTimelineLayout.razor does (use the same whitespace filtering), and
split the logic into separate flags/counts for actual unassigned events versus
the fallback “no resources” row. Make sure the grouping and render checks around
the hasUnassigned path and the unassigned lane rendering only run when grouped
actually contains the unassigned key, so empty calendars do not attempt to
access missing unassigned data.

In
`@src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/Views/TimelineMode/BitFcTimelineEventBlock.razor.cs`:
- Around line 66-80: Track resize initialization separately for each handle in
BitFcTimelineEventBlock.OnAfterRenderAsync instead of using a single
_resizeInitialized flag for both registrations. If initResizeHorizontal succeeds
for the start handle but fails for the end handle, remember the successful side
so the next render only retries the missing handle and does not re-register the
already-initialized one. Update the state management around _dotNetRef,
_startHandleId, and _endHandleId to avoid duplicate listeners and repeated
resize callbacks.